System and method for higher level filtering by combination of bilinear results

ABSTRACT

A method and system for higher level filtering uses a native bilinear filter, typically found in a texture mapper, and combines a plurality of bilinear filter results from the bilinear filter to produce a higher level filtered texel value. A native bilinear filter is operative to generate bilinear filtered texel values by performing a plurality of bilinearly filtered texture fetches using bilinear filter fetch coordinates. The method and system combines the plurality of bilinear filtered texel values with a plurality of weights to generate the higher level filtered texel value.

FIELD OF THE INVENTION

The present invention relates generally to graphics image processing andmore specifically to improved higher level filtering.

BACKGROUND OF THE INVENTION

In a graphics processing environment, image filtering allows forimproved image quality in a rendered display. Two common filteringapproaches are a multi-tap filter which is used for high-quality videoor anti-aliased text and pixel shader code and two by two (bi-linear)filtering for a texture maps. Bilinear filters adjust the color of apixel by computing a weighted average of a 2×2 array of texels that lienearest to the center of the calculated pixel. The weighted averagecolor is then assigned to the pixel. Multi-tap filters are generallyexpensive in terms of not only components for performing theseoperations, but also in processing time. A multi-tap filter complicatesa standard graphics processing pipeline through requiring furtherprocessing steps and extended computation time.

A typical three-dimensional graphics processing system natively providesa two-by-two bilinear filter. A single address fetch by the filterresults in 4 texels being returned. When an application requires ahigher level of taps (higher level filtering), such as a 4×4 filter,this native bilinear filter is inadequate.

A solution to overcome the limitations of the native bilinear filter isutilizing pure pixel shader code. In this embodiment, a pixel shaderthat includes one or more ALUs includes specific code, such asexecutable instructions operated on a graphics processing unit, thatperforms the filtering functionality. In any situation where scalingoccurs, such as the source and destination are not the same size or theoutput pixel does not align exactly to input texels, different weightsets are needed to compensate for the possible different sub-pixelalignments. Utilizing pixel shader code is generally slow because, amongother things, two texture fetches are needed for each tap, one fetch isneeded to fetch the weight of the texel value and one fetch is needed tofetch the texel value to be weighted. Furthermore, using pure pixelshader code, typically only “pick nearest” filtering can be used by thetexture fetches, meaning that only one texel is returned for each fetchrequest and another 16 fetches can be required for the correspondingweights for a total of 32 fetches. It will be recognized that if aweight applies equally to four texels, fewer weight fetches may beneeded (e.g., perhaps only four fetches to obtain the weights for 16texels) however, the total number of fetches may still be unnecessarilyhigh.

When enlarging an image, the filtering allows scaling the image andthereby creating more pixels between input texels. The quality of thescaling is largely determined by the width and height of the filterfootprint. Increasing the number of taps, i.e. samples, directlyincreases the image quality.

Therefore, there exists a need for an improved graphics processingsystem allowing for higher level filtering without extensive processingoverhead costs, such as by using fewer fetches utilizing existing systemresources.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates a system for higher level filtering using bilinearresults in accordance with one embodiment of the present invention;

FIG. 2 illustrates a flowchart of the method for higher level filteringusing bilinear results in accordance with one embodiment of the presentinvention;

FIG. 3 illustrates a graphical representation of a 4×4 weighted matrixarray;

FIG. 4 illustrates another flow chart of a method for pre-computingvalues used by the present invention;

FIG. 5 illustrates a flowchart of a method for higher level filtering inaccordance with one embodiment of the invention; and

FIG. 6 is a block diagram illustrating one example of graphicsprocessing system in accordance with one embodiment of the invention.

DETAILED DESCRIPTION OF A PREFERRED EMBODIMENT

Generally, the present invention includes a method and system for higherlevel filtering that uses a native bilinear filter and combines aplurality of bilinear filter results from the bilinear filter to producea higher level filtered texel value. The bilinear filter may be abilinear filter found within a standard graphics processing system orthe bilinear filter may be any suitable filter natively disposed withinany graphics processing system or circuit, subsystem or system. Forpurposes of illustration only, and not limitation, the invention will bedescribed with reference to texels and sub-texel portions although itwill be recognized that the invention is also applicable to pixels andsub pixel portions and associated pixel operations (e.g. generating afiltered pixel).

In one embodiment, a graphics processing system that includes a texturemapping subsystem employs a higher level filter for image processingusing fewer fetches. The higher level filter includes one or morebilinear filters located within a texture mapping subsystem. A combinerreceives bilinear filtered texel values from the bilinear filter and isoperative to combine the plurality of bilinear filtered texel values andcorresponding weights to produce a higher level filtered texel value. Amethod is also disclosed which includes sending a texel coordinate toone or more bilinear filters, receiving from the bilinear filters aplurality of bilinear filtered texel values in response to the sendingof the texel coordinates and combining the received bilinear filtertexel values with weights in order to generate the higher level filteredtexel value. For example, when processing an image based on graphicsinformation, texels are fed into a bilinear filter and the outputs fromthe bilinear filter are weighted and combined to produce a higher levelfiltered texel value. The texel value may then be processed further ordisplayed on a suitable display as part of the image.

In one embodiment, the present invention includes receiving an initialtexel fetch coordinate, such as (S, T) texels coordinates where, forexample, the S and T texel coordinate may each include a texel portion(e.g., that points to a stored texture), such as an integer portion(denoted (Sint, Tint)) and a subtexel portion, such as a fractionalportion, as known in the art. Corresponding weights may be generatedusing the sub-texel portion, denoted as (Sfract, Tfract), of the texelcoordinate (S, T). The present invention includes generating a pluralityof new sub texel portions from the sub texel portion of the initialtexel fetch coordinate. Similarly, the method includes generating aplurality of new texel portions from the texel portion of the initialtexel fetch coordinate. These plurality of new texel portions andsubtexel portions that are all based on the initial texel fetchcoordinate, are used to generate a new set of bilinear filter fetchcoordinates that are used by a native bilinear filter (e.g., four newsets of (S, T)). For example, the new set of S, T bilinear filter fetchcoordinates are generated for surrounding texels by the originalcoordinates being broken into integer portions, e.g. (Sint−1, Tint−1),(Sint−1, Tint), (Sint, Tint−1), (Sint, Tint). The corresponding newsubtexel portions are generated from the original subtexel portions viatable look-up. In one embodiment, 4 new Sfract values may be looked upusing the original Sfract value via a 1D texture fetch. Similarly the 4new Tfract values may be generated via a separate 1D texture fetch. Thenew texel portions and new subtexel portions are then combined to form 4new (S, T) addresses.

The present invention performs 4 bilinear filter operations in anexemplary embodiment of a 4×4 filter. For each group of 2×2 texels thatcontribute to the filter, the present invention generates a texeladdress (S, T), wherein these addresses may be used as input to thebilinear filter. The bilinear filter performs standard bilinear filteroperations using the texel addresses.

A plurality of bilinearly filtered texel values, such as TexelQ0 throughTexelQ3 may be generated by the bilinear filter, using well knownbilinear filter operations. The present invention further includescombining the plurality of bilinearly filtered texel values with theplurality of corresponding weights to generate a higher level filteredtexel value. Therefore, the higher level filtered texel value isgenerated using a reduced number of texture fetches through theutilization of the native bilinear filter compared to using a shaderthat requires per texel fetching when carrying out a 4×4 higher levelfilter operation.

More specifically, FIG. 1 illustrates a system 100 that includes ahigher level filter 101 that includes filter logic, such as a texturemapping subsystem 103 and a combiner 104. The system 100 may be anysuitable system that employs a graphics processing system, such as agraphics processor or other suitable graphics processing circuitry. Thesystem 100 may include, for example, a device or apparatus that employsthe graphics processing system such as, but not limited to, a handheldcellphone, a camera, printer, set top box, laptop computer, desktopcomputer, handheld computing device, or any other suitable device orsystem. As such, the system 100 may or may not include a display 105that eventually displays a higher level filtered value produced by thedisclosed higher level filter 101. The texture mapping subsystem 103includes a native bilinear filter 102 and texture map 118. The combiner104 may be any suitable type of processing device as recognized by onehaving ordinary skill in the art and in one embodiment of the presentinvention, the combiner 104 is disposed within a shader 110 of agraphics processor. It will be recognized that any suitable structure orprocessor may be used. The processor may be, but is not limited to, asingle processor, a plurality of processors, a DSP, a microprocessor,ASIC, state machine, or any other implementation capable of processingand executing software or firmware. The term processor should not beconstrued to refer exclusively to hardware capable of executingsoftware, and may implicitly include DSP hardware, ROM for storingsoftware, RAM, and any other volatile or non-volatile storage medium.The native bilinear filter 102, in this example, fetches a 2×2 “quad” oftexels based on a received new bilinear filter fetch coordinate 106determined and provided by the shader 110 via a table look up, in thisexample. In one embodiment, the new bilinear filter fetch coordinate 106may be referred to as (S, T) coordinates having new sub-texel portionsthat may be designated as (Sfract, Tfract). In one embodiment the newbilinear filter fetch coordinate 106 may be received from the shader110, and in particular from the combiner 104 within the shader. Thecombiner 104 is operative to access, using texture fetch logic as knownin the art, the look-up table 114 in memory 115 (in this example atexture map in memory), containing weight values therein and the newsubtexel portions to generate the new sub-texel coordinates. The newsubtexel portions are generated in this example by looking them up inthe LUT 114 based on the initial subtexel portion that is part of theinitial bilinear filter fetch coordinate. Alternatively, instead ofusing a look up table, the combiner 104 may calculate the weights andnew subtexel portions as needed.

The combiner 104 is operative to determine a plurality of new sub-texelportions 112 based on sub-texel portions of the initial texelcoordinate, such as locations (Sfract, Tfract). In one embodiment, thesub-texel coordinates may be referred to as (BifractSQ0, BifractTQ0)through (BifractSQ3, BifractTQ3) for an exemplary four by four pixelarray.

In the exemplary embodiment of the four by four pixel array, the shader110 utilizes the texel address (S, T), which points into the middle of atexture grid that is the subject of filtering. From initial (S, T), thepresent invention creates four new S, T coordinates, referred to as newbilinear filter fetch coordinates 106 as they are used for the bilinearfilter to fetch texel information for filtering, which each refer to atwo by two block of the sixteen texel block. The present inventiongenerates weighting, in this example by obtaining weights 113 (see FIG.6) by using a look up table 114 to apply to the results of the bilinearfilter.

In one embodiment, the combiner 104 is disposed within the shader 110,such as a pixel shader. The combiner 104, in accordance with executableinstructions, generates a higher level filtered value 124 based on thecombination of the weights and the bilinear filtered texel values 122from the native bilinear filter 102.

In one embodiment, the plurality of bilinear filtered texel values arecombined with the weight values to generate a higher level filteredtexel value, wherein this operation may be performed by the combiner 104within the shader 110. The higher level filtered texel value may becomputed based on the addition of the combination of correspondingweights and bilinear filtered texel values. For example, in an exemplaryembodiment of a four by four pixel array, the higher level filteredvalue 124 may be determined based on Equation 1.Higher Level Filtered Value=(WeightQ0*TexelQ0)+(WeightQ1*TexelQ1)+(WeightQ2*TexelQ2)+(WeightQ3*TexelQ3)  Equation 1:

The present invention generates the higher level filtered texel value124 using a significantly reduced number of computations. In theexemplary embodiment of the four by four array, a reduced number offetches are utilized to generate the addresses for the bilinear fetch,four fetches for each of the Sfract, four fetches for each of theTfract, four fetches for each of the weights Q, and 4 fetches forbilinear fetch. In one embodiment, the present invention utilizes a 4:1encoding efficiency based on ARGB packing, as discussed in greaterdetail below.

Therefore, the present invention provides for a total of 8 fetches forthe Sfract and Tfract (address generation), 4 fetches of the nativebilinear filter and 4 fetches for Weight fetches, as compared to a totalof 16 fetches for the pick-nearest version of fetching taps plus 16weight fetches. Using packed weights optimization, weight fetches andfetches for Sfract, Tfract are reduced by a factor of four to generate 7total fetches versus 20 fetches in normal approach using optimizedpacking of ARGB format. In relation to ALU operations—the prior approachrequires at least sixteen computational operations to combine weighttimes tap and accumulate the results.

The present invention requires only four ALU operations to combineweight times filter tap and accumulate the results by the combiner 104.As recognized by one having ordinary skill in the art, the fetchingoperations may be performed relative to any suitable memory device, suchas a look-up table or any other suitable memory location.

FIG. 2 illustrates a flowchart of the steps of one embodiment of amethod for higher level bilinear filtering. The method begins bygenerating a plurality of weights in response to a sub-texel portion ofan initial texel fetch coordinate, step 130. In one embodiment, theweights are determined based on a positioning relative to texel values.For example, the combiner 104 of FIG. 1, in response to the receivedtexel values 106, determines a plurality of weight values, such as usinga predetermined lookup table 114. In one exemplary embodiment in a 4×4matrix array, FIG. 3 illustrates a weighted matrix 140 having aplurality of weight factors, W00-W30, W10-W30, W02-W32 and W03-W33. Inone embodiment, a horizontal ratio and a vertical ratio may bedetermined based on a relationship between the weights, as discussedbelow.

With the combiner 104, the next step of the method is generating aplurality of new subtexel portions from the subtexel portion of theinitial texel fetch coordinate, step 132. As shown in block 133, themethod includes generating a plurality of new texel portions from thetexel portion of the initial texel fetch coordinate. Step 134 isgenerating a plurality of new bilinear filter fetch coordinates usingthe plurality of generated sub-texel portions in combination withgenerated plurality of texel portions. For example, if the generatedsub-texel portions are defined as (BiFractSQ0, BiFractTQ0) through(BiFractSQ3, BiFractTQ3) and the generated texel portions are defined as(Sint−1, Tint−1) through (Sint+1, Tint+1), the new bilinear filter fetchcoordinates would be (Sint−1+BiFractSQ0, Tint−1+BiFractTQ0),(Sint+1+BiFractSQ1, Tint−1+BiFractTQ1), (Sint−1+1 BiFractSQ2,Tint+1+BiFractTQ2) and (Sint+1+BiFractSQ3, Tint+1+BiFractTQ3).

Step 136 is generating a plurality of bilinear filtered texel values(e.g., each bilinear filtered texel value is generated from each fetchcoordinate) by performing a plurality of filtered texture fetches usingthe generated bilinear filter fetch coordinates. In one embodiment, thefetching is performed from the texture map 118 using the bilinear filterfetch coordinates generated in step 134. Step 138 is combining theplurality of bilinear filtered texel values and the weights, usingcombining logic such as an arithmetic logic unit, to generate a higherlevel filtered texel value. The higher level filtered texel value 124 iscomputed as the compilation of multiple calculated bilinear filteredtexel values, wherein previously calculated bilinear filtered texelvalues may be calculated using the above-noted steps of the presentinvention. In one embodiment, the previously calculated values may bestored within a temporary register connected to or disposed within thecombiner 104 of FIG. 1. The higher level filtered texel value 124 isthereupon provided for further graphics processing in accordance with apixel processing pipeline or output for display if desired. As there isa significant reduction in the amount of computation required, there isa reduction in the amount of subsequent computations.

The present invention generates a similar output as prior arttechniques, but provides for the generation of this similar result usinga reduced number of fetching and processing operations. The presentinvention allows for the generation of one or more equations to simulateweights for a given a sub-texel position, e.g. (W00-W03, W30-W33) tableof FIG. 3, and texture coordinates (S0, T0)-(S3, T3) in the exemplaryfour by four matrix array. The present invention utilizes an initialpointer to initial texture coordinates (Sint, Tint), otherwise referredto as the integer portions which point to an exact texel. The presentinvention further utilizes the fraction portion (Sfract, Tfract), whichis the offset value. A basic pick-nearest approach, fetches pixel asSint−1, Tint−1 times W00, fetches texel Sint, Tint−1 times W01, for allsixteen pixel in the exemplary four by four matrix array. The priortechniques also therein compute sixteen weights multiplied by sixteentexel fetches.

The present invention utilizes data manipulation to achieve efficientcomputation and fetching operations. As discussed below, based on datamanipulation, the similar result of bilinear filter operations may bemore effectively performed using the present invention in conjunctionwith the below-noted equations.

More specifically, in one embodiment through the utilization of thebilinear filter, FIG. 4 illustrates a method of an exemplary calculationof the lookup table values used for a single bilinear fetch in thepresent invention. The method begins 200 by receiving a plurality ofinitial filter weights (W00-W11) step 202. These initial weights areassociated with a particular sub-texel alignment and would be the valuesto be used to multiply pixels P00 through pixels P00 in the known art.

Step 204 is generating new Sfract, Tfract values that will be placed inthe look-up table for that particular sub-texel alignment. The look-uptable values are based on the horizontal ratios and the vertical ratiosof the initial filter weights. In one exemplary embodiment, FIG. 3illustrates a plurality of weights. Step 206 is generating the scalefactors using the horizontal ratios and the vertical ratios.

In one embodiment, the horizontal ratio can be determined based on thefraction of a first weight and a second weight in a horizontalrelationship, such as the relation of W00 and W01 of FIG. 3.W00/W10=W01/W11=horizontal ratio  Equation 2:

The vertical ratio is further computed based on the spatial relationshipbetween the various weights in a vertical relationship, such as thequotient or fraction of W00 and W10 of FIG. 3.W11/W12=W21/W22=vertical ratio  Equation 3:

The horizontal ratio is applicable to all relative weights in ahorizontal relationship and the vertical ratio is relative to allweights in a corresponding vertical relationship. Moreover, this ratiorelationship exists for all filters that are separable.

Step 206 is generating the ‘fraction factors’ that are the entries inthe Sfract and TFract lookup tables. For example, the first fractionfactor is generated as the ratio of the horizontal ratio divided by thesum of 1 plus the horizontal ratio and the second fraction factor is thevertical ratio divided by the sum of 1 plus the vertical ratio.First fraction:Sfract=(h_ratio/(1+h_ratio))  Equation 4:Second fraction:Tfract=(v_ratio/(1+v_ratio))  Equation 5:

Step 208 is generating the new bilinear filter weight, WeightQ0.Normalizing the first and second fractions in the accompanying x and ydirections provides that, in one embodiment, WeightQ0 may be calculatedas noted in Equation 6.W00*(1+h_ratio)(1+v_ratio)  Equation 6:

In one embodiment, the combined bilinear term and scale factor may berepresented as equation 7 based on the vertical ratio, the horizontalratio, the first fraction factor and the second fraction factor.W00*(1+h_ratio)(1+v_ratio)*[[((p00*(1−Sfract)+p10*Sfract)*(1−Tfract)]+(p01*(1−Sfract)+p11*Sfract)*Tfract)]  Equation7:

Equation 7 represents the resulting value after the bilinear filteringand multiplication of the bilinear weight for the quad of texels in theupper left of the sample region. For a full higher level filter,Equation 7 is repeated for each of the 2×2 regions in the sample region,combining the results. The bilinear weights and replacement Sfract,Tfract associated with the different 2×2 regions in the sample regionare computed in a similar manner to that shown above, simply using theset of initial weights associated with the respective region. The firstcomputational element of Equation 7, (W00*(1+h_ratio)(1+v_ratio)), maybe pre-computed as described above and stored in a look-up table suchthat this element may be retrieved as a bilinear weight and does not tobe repetitively computed. Similarly the Sfract and Tfract terms may bepre-computed and looked up. Furthermore, bracketed term of equation 7represents the math done by the native bilinear filter if Sfract andTfract are provided as the sub-texel portions of the texel address.

Therefore, the computation of the bracketed portion of equation 7 may beperformed by the native bilinear filter and a final bilinear weightmultiply may be performed in the processor disposed within the pixelshader. The above-noted equations 2-6 may be calculated by apre-processor, as discussed above, and the values received by thebilinear filter. The method allows for improved higher level bilinearfiltering through the effective utilization of both components. In oneembodiment, the bilinear weight multiply may thereupon be implemented inthe shader code and operated to perform calculations and the bilinearterm is generated by the texture fetch unit to produce the bilinear termcalculated by the bilinear function. As noted above, the scale factorsand the ratios may be determined using a pre-processing technique basedon the initial weight values.

FIG. 6 diagrammatically illustrates one example of system employing abilinear filter having four parallel filters instead of a system thatreuses one bilinear filter and multiple passes through the same filter.Its operation is similar to that described above with respect to FIGS.2-5.

As recognized by one having ordinary skill in the art, the computationsand techniques for data transformation of the present invention,including the above-noted equations, provide an equivalent actual resultas the prior art computational techniques. For example, the resultantcomputation of Equation 7 produces the same result as the prior artcomputation of summing the multiplications of texels and weights (e.g.W00*p00+W10*p10+W01*p00+W11*p11). However, the present inventionprovides for improved computation through the effective utilization ofexisting computation resources and the manipulation of computationalterms, such as the generation of Equation 7 above.

As shown in FIG. 5, a method for higher level filtering is illustratedas taken from the perspective of the combiner shown in FIG. 1. However,any suitable structure may carry out the disclosed operations. As shownin block 500, the method includes sending a texel coordinate 106 to oneor more bilinear filters 102 in a texture mapping subsystem 103. Asshown in block 502, the method includes receiving from the bilinearfilter 102, a plurality of bilinear filtered texel values 122 inresponse to sending the new texel coordinate 106. As shown in block 138,the method includes combining the received bilinear filtered texelvalues 122 provided by the bilinear filter, with corresponding weights,in order to generate the higher level filtered texel value 124. This maybe done, for example, by suitable arithmetic combining logic. As shownin block 504, the higher level filtered texel value may be furtherprocessed in a pipeline or by other suitable processing stage or may bedisplayed as a pixel in an image on a display.

As such, in one embodiment, utilization of the bilinear filter requiresa reduced number of weights and uses fewer fetches than pick nearestfiltering techniques performed by a shader. For example, in a four byfour matrix, the prior art utilizes sixteen (16) weights, wherein thepresent invention utilizes four weights. A total number of thirteeninstructions (7 fetches and 6 ALU shader instructions) are used by theinstant method and apparatus for a four by four matrix. These fetchesfor a 4×4 texel include the Sfract values, the Tfract values and 4weights which are applied to the output of the bilinear filter such thatnative hardware is reused multiple times to effectively build up alarger bilinear filter by combining results from multiple passes (i.e.,uses) of the native bilinear filter hardware. Pick nearest filteringusing shader operations can result in thirty six instructions (16fetches for the texels, 4 fetches for the weights and 16 ALU operationsto determine the higher level filtered value). The present invention mayutilize, for example, four bilinear texel fetches rather than 16pick-nearest fetches of the prior techniques while using the samehardware based bilinear filters as prior art techniques. Also, inanother embodiment, for example, four parallel bilinear filters (4bilinear filter fetches in parallel) could be used instead of re-usingthe same native filter logic multiple times.

It should be understood that the implementation of other variations andmodifications of the invention and its various aspects will be apparentto those of ordinary skill in the art, and that the invention is notlimited by the specific embodiments described herein. For example, thecombiner 104 may be incorporated into any element within the pixelprocessing pipeline such that the pixel shader may utilize and generatethe proper pixel processing output. It is therefore contemplated tocover by the present invention, any and all modifications, variations,or equivalents that fall within the spirit and scope of the basicunderlying principles disclosed and claimed herein.

What is claimed is:
 1. Within a graphics processing system that includesa texture mapping subsystem, a higher level filter for image processingcomprising: one or more bilinear filters, located within the texturemapping subsystem, that are operative to provide one or more bilinearfiltered texel values in response to one or more fetch coordinates; anda combiner that is operative to provide the one or more fetchcoordinates and to provide a higher level filtered texel value inresponse to the one or more bilinear filtered texel values.
 2. Thefilter of claim 1 wherein the combiner is operative to provide thehigher level filtered texel value by weighting the one or more bilinearfiltered texel values and summing the weighted one or more bilinearfiltered texel values.
 3. A method of generating a higher level filteredtexel value within a graphics processing system, which system includes atexture mapping subsystem that includes at least one bilinear filter anda combiner, the method comprising: sending, via the combiner, a texelcoordinate to the at least one bilinear filter; receiving from the atleast one bilinear filter a plurality of bilinear filtered texel valuesin response to the texel coordinate; and combining, via the combiner,the received bilinear filtered texel values with weights in order togenerate a higher level filtered texel value.
 4. A method of generatinga higher level filtered texel value within a graphics processing system,the method comprising: generating a plurality of weights in response toa sub-texel portion of initial texel fetch coordinates; generating aplurality of new sub-texel portions from the sub-texel portion of theinitial texel fetch coordinates; generating a plurality of new texelportions from a texel portion of the initial texel fetch coordinates;generating a plurality of new bilinear filter fetch coordinates based onthe generated new texel portions and the generated new sub-texelportions; generating bilinear filtered texel values by performing aplurality of bilinearly filtered texture fetches using the generatedbilinear filter fetch coordinates; and combining the plurality ofbilinear filtered texel values and the plurality of generated weights toproduce a higher level filtered texel value.
 5. The method of claim 4,wherein the weights are based on a monochrome weighting.
 6. The methodof claim 4 wherein generating a plurality of new sub-texel portionsfurther includes: fetching the new sub-texel portion from a look-uptable.
 7. The method of claim 4 wherein performing a plurality ofbilinearly filtered texture fetches comprises fetching a plurality oftexel data from a texture map.
 8. The method of claim 4 whereincombining the plurality of bilinear filtered texel values and theplurality of weights includes summing the products of each of aplurality of bilinear filtered texel values with corresponding weights.9. The method of claim 4 wherein the combining the plurality of bilinearfiltered texel values and the plurality of weights is performed by ashader.
 10. A method of generating a higher level filtered texel valuewithin a graphics processing system, the method comprising: generating aplurality of weights from a first texture map based on an initialsub-texel coordinate; generating a plurality of sub-texel portions basedon the initial sub-texel coordinate; generating a plurality of bilinearfilter fetch coordinates based on the generated sub pixel sub-texelportions and the initial texel fetch coordinate; fetching a plurality oftexel data based on the bilinear filter fetch coordinates from a secondtexture map; and combining the plurality of texel data and the pluralityof generated weights.
 11. The method of claim 10 wherein combining theplurality of texel data and the plurality of generated weights includessumming the products of each of the plurality of texel data withcorresponding generated weights.
 12. The method of claim 10 whereincombining the plurality of texel data and the plurality of generatedweights is performed by a shader.
 13. A method of generating a higherlevel filtered texel value within a graphics processing system, themethod comprising: receiving at least one initial pixel coordinate;generating a plurality of weights in response to a sub-pixel portion ofsaid initial pixel coordinates; generating a plurality of new sub-pixelportions from the sub-pixel portion of the initial pixel coordinates;generating a plurality of new pixel portions from the pixel portion ofthe initial pixel coordinates; generating a plurality of new bilinearfilter fetch coordinates based on the generated new pixel portions andthe generated new sub-pixel portions; generating bilinear filtered pixelvalues by performing a plurality of bilinearly filtered pixel operationsusing the generated bilinear filter coordinates; and combining theplurality of bilinear filtered pixel values and the plurality ofgenerated weights to produce a higher level filtered pixel value. 14.The method of claim 13 wherein the weights are based on a monochromeweighting.
 15. The method of claim 13 wherein generating a plurality ofnew sub-pixel portions further includes: fetching the new sub-pixelportion from a look-up table.
 16. The method of claim 13 whereinperforming a plurality of bilinearly filtered texture fetches comprisesfetching a plurality of pixel data.
 17. The method of claim 13 whereincombining the plurality of bilinear filtered pixel values and theplurality of weights includes summing the products of each of aplurality of bilinear filtered pixel values with corresponding weights.